import request from '@/utils/request'

/**
 * 节点定义API接口
 */

/**
 * 分页查询节点定义列表
 * @param {Object} params 查询参数
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionList(params) {
  return request({
    url: '/api/node-definitions',
    method: 'get',
    params
  })
}

/**
 * 分页查询节点定义列表（带分页参数）
 * @param {Object} params 查询参数，包含current、size等分页参数
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionPage(params) {
  return request({
    url: '/api/node-definitions/page',
    method: 'get',
    params
  })
}

/**
 * 根据ID获取节点定义详情
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionById(id) {
  return request({
    url: `/api/node-definitions/${id}`,
    method: 'get'
  })
}

/**
 * 根据节点编码获取节点定义
 * @param {string} nodeCode 节点编码
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionByCode(nodeCode) {
  return request({
    url: `/api/node-definitions/code/${nodeCode}`,
    method: 'get'
  })
}

/**
 * 创建节点定义
 * @param {Object} data 节点定义数据
 * @returns {Promise} 响应结果
 */
export function createNodeDefinition(data) {
  return request({
    url: '/api/node-definitions',
    method: 'post',
    data
  })
}

/**
 * 更新节点定义
 * @param {string|number} id 节点定义ID
 * @param {Object} data 更新数据
 * @returns {Promise} 响应结果
 */
export function updateNodeDefinition(id, data) {
  return request({
    url: `/api/node-definitions/${id}`,
    method: 'put',
    data
  })
}

/**
 * 删除节点定义
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function deleteNodeDefinition(id) {
  return request({
    url: `/api/node-definitions/${id}`,
    method: 'delete'
  })
}

/**
 * 批量删除节点定义
 * @param {Array} ids 节点定义ID数组
 * @returns {Promise} 响应结果
 */
export function batchDeleteNodeDefinitions(ids) {
  return request({
    url: '/api/node-definitions/batch',
    method: 'delete',
    data: { ids }
  })
}

/**
 * 复制节点定义
 * @param {string|number} id 源节点定义ID
 * @param {Object} data 复制配置
 * @returns {Promise} 响应结果
 */
export function copyNodeDefinition(id, data) {
  return request({
    url: `/api/node-definitions/${id}/copy`,
    method: 'post',
    data
  })
}

/**
 * 启用节点定义
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function enableNodeDefinition(id) {
  return request({
    url: `/api/node-definitions/${id}/enable`,
    method: 'put'
  })
}

/**
 * 禁用节点定义
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function disableNodeDefinition(id) {
  return request({
    url: `/api/node-definitions/${id}/disable`,
    method: 'put'
  })
}

/**
 * 批量更新节点定义状态
 * @param {Array} ids 节点定义ID数组
 * @param {string} status 状态值
 * @returns {Promise} 响应结果
 */
export function batchUpdateNodeDefinitionStatus(ids, status) {
  return request({
    url: '/api/node-definitions/batch/status',
    method: 'put',
    data: { ids, status }
  })
}

/**
 * 获取节点定义统计信息
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionStats() {
  return request({
    url: '/api/node-definitions/stats',
    method: 'get'
  })
}

/**
 * 获取节点分类统计信息
 * @returns {Promise} 响应结果
 */
export function getNodeCategoryStats() {
  return request({
    url: '/api/node-definitions/stats/categories',
    method: 'get'
  })
}

/**
 * 检查节点编码是否存在
 * @param {string} nodeCode 节点编码
 * @param {string|number} excludeId 排除的ID（用于编辑时检查）
 * @returns {Promise} 响应结果
 */
export function checkNodeCodeExists(nodeCode, excludeId = null) {
  const params = { nodeCode }
  if (excludeId) {
    params.excludeId = excludeId
  }
  return request({
    url: '/api/node-definitions/check-code',
    method: 'get',
    params
  })
}

/**
 * 验证节点Schema
 * @param {Object} data Schema数据
 * @returns {Promise} 响应结果
 */
export function validateNodeSchema(data) {
  return request({
    url: '/api/node-definitions/validate-schema',
    method: 'post',
    data
  })
}

/**
 * 测试节点定义
 * @param {string|number} id 节点定义ID
 * @param {Object} data 测试数据
 * @returns {Promise} 响应结果
 */
export function testNodeDefinition(id, data) {
  return request({
    url: `/api/node-definitions/${id}/test`,
    method: 'post',
    data
  })
}

/**
 * 获取节点类型列表
 * @returns {Promise} 响应结果
 */
export function getNodeTypes() {
  return request({
    url: '/api/node-definitions/types',
    method: 'get'
  })
}

/**
 * 获取节点分类列表
 * @returns {Promise} 响应结果
 */
export function getNodeCategories() {
  return request({
    url: '/api/node-definitions/categories',
    method: 'get'
  })
}

/**
 * 获取启用的节点定义列表
 * @param {Object} params 查询参数
 * @returns {Promise} 响应结果
 */
export function getEnabledNodeDefinitions(params = {}) {
  return request({
    url: '/api/node-definitions/enabled',
    method: 'get',
    params
  })
}

/**
 * 获取系统内置节点定义列表
 * @returns {Promise} 响应结果
 */
export function getSystemNodeDefinitions() {
  return request({
    url: '/api/node-definitions/system',
    method: 'get'
  })
}

/**
 * 获取自定义节点定义列表
 * @param {Object} params 查询参数
 * @returns {Promise} 响应结果
 */
export function getCustomNodeDefinitions(params = {}) {
  return request({
    url: '/api/node-definitions/custom',
    method: 'get',
    params
  })
}

/**
 * 导出节点定义
 * @param {Array} ids 节点定义ID数组（可选，不传则导出全部）
 * @returns {Promise} 响应结果
 */
export function exportNodeDefinitions(ids = null) {
  const params = ids ? { ids: ids.join(',') } : {}
  return request({
    url: '/api/node-definitions/export',
    method: 'get',
    params,
    responseType: 'blob'
  })
}

/**
 * 导入节点定义
 * @param {FormData} formData 包含文件的表单数据
 * @returns {Promise} 响应结果
 */
export function importNodeDefinitions(formData) {
  return request({
    url: '/api/node-definitions/import',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  })
}

/**
 * 获取节点定义版本历史
 * @param {string} nodeCode 节点编码
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionVersions(nodeCode) {
  return request({
    url: `/api/node-definitions/versions/${nodeCode}`,
    method: 'get'
  })
}

/**
 * 获取最新版本的节点定义
 * @param {Object} params 查询参数
 * @returns {Promise} 响应结果
 */
export function getLatestNodeDefinitions(params = {}) {
  return request({
    url: '/api/node-definitions/latest',
    method: 'get',
    params
  })
}

/**
 * 搜索节点定义
 * @param {Object} params 搜索参数
 * @returns {Promise} 响应结果
 */
export function searchNodeDefinitions(params) {
  return request({
    url: '/api/node-definitions/search',
    method: 'get',
    params
  })
}

/**
 * 获取节点定义的依赖关系
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionDependencies(id) {
  return request({
    url: `/api/node-definitions/${id}/dependencies`,
    method: 'get'
  })
}

/**
 * 获取使用指定节点定义的流程列表
 * @param {string|number} id 节点定义ID
 * @returns {Promise} 响应结果
 */
export function getNodeDefinitionUsage(id) {
  return request({
    url: `/api/node-definitions/${id}/usage`,
    method: 'get'
  })
}

/**
 * 预览节点定义配置
 * @param {Object} data 节点定义数据
 * @returns {Promise} 响应结果
 */
export function previewNodeDefinition(data) {
  return request({
    url: '/api/node-definitions/preview',
    method: 'post',
    data
  })
}

/**
 * 生成节点定义模板
 * @param {string} nodeType 节点类型
 * @returns {Promise} 响应结果
 */
export function generateNodeTemplate(nodeType) {
  return request({
    url: `/api/node-definitions/template/${nodeType}`,
    method: 'get'
  })
}

/**
 * 保存测试用例
 * @param {Object} data 测试用例数据
 * @returns {Promise} 响应结果
 */
export function saveTestCase(data) {
  return request({
    url: '/api/node-definitions/test-cases',
    method: 'post',
    data
  })
}

/**
 * 获取测试用例列表
 * @param {string|number} nodeId 节点定义ID
 * @returns {Promise} 响应结果
 */
export function getTestCases(nodeId) {
  return request({
    url: `/api/node-definitions/${nodeId}/test-cases`,
    method: 'get'
  })
}

/**
 * 运行测试用例
 * @param {string|number} testCaseId 测试用例ID
 * @returns {Promise} 响应结果
 */
export function runTestCase(testCaseId) {
  return request({
    url: `/api/node-definitions/test-cases/${testCaseId}/run`,
    method: 'post'
  })
}